{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-title"
    ]
   },
   "source": [
    "# Fully-Connected Neural Nets\n",
    "In the previous homework you implemented a fully-connected two-layer neural network on CIFAR-10. The implementation was simple but not very modular since the loss and gradient were computed in a single monolithic function. This is manageable for a simple two-layer network, but would become impractical as we move to bigger models. Ideally we want to build networks using a more modular design so that we can implement different layer types in isolation and then snap them together into models with different architectures."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "source": [
    "In this exercise we will implement fully-connected networks using a more modular approach. For each layer we will implement a `forward` and a `backward` function. The `forward` function will receive inputs, weights, and other parameters and will return both an output and a `cache` object storing data needed for the backward pass, like this:\n",
    "\n",
    "```python\n",
    "def layer_forward(x, w):\n",
    "  \"\"\" Receive inputs x and weights w \"\"\"\n",
    "  # Do some computations ...\n",
    "  z = # ... some intermediate value\n",
    "  # Do some more computations ...\n",
    "  out = # the output\n",
    "   \n",
    "  cache = (x, w, z, out) # Values we need to compute gradients\n",
    "   \n",
    "  return out, cache\n",
    "```\n",
    "\n",
    "The backward pass will receive upstream derivatives and the `cache` object, and will return gradients with respect to the inputs and weights, like this:\n",
    "\n",
    "```python\n",
    "def layer_backward(dout, cache):\n",
    "  \"\"\"\n",
    "  Receive dout (derivative of loss with respect to outputs) and cache,\n",
    "  and compute derivative with respect to inputs.\n",
    "  \"\"\"\n",
    "  # Unpack cache values\n",
    "  x, w, z, out = cache\n",
    "  \n",
    "  # Use values in cache to compute derivatives\n",
    "  dx = # Derivative of loss with respect to x\n",
    "  dw = # Derivative of loss with respect to w\n",
    "  \n",
    "  return dx, dw\n",
    "```\n",
    "\n",
    "After implementing a bunch of layers this way, we will be able to easily combine them to build classifiers with different architectures.\n",
    "\n",
    "In addition to implementing fully-connected networks of arbitrary depth, we will also explore different update rules for optimization, and introduce Dropout as a regularizer and Batch/Layer Normalization as a tool to more efficiently optimize deep networks.\n",
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=========== You can safely ignore the message below if you are NOT working on ConvolutionalNetworks.ipynb ===========\n",
      "\tYou will need to compile a Cython extension for a portion of this assignment.\n",
      "\tThe instructions to do this will be given in a section of the notebook below.\n",
      "\tThere will be an option for Colab users and another for Jupyter (local) users.\n"
     ]
    }
   ],
   "source": [
    "# As usual, a bit of setup\n",
    "from __future__ import print_function\n",
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from cs231n.classifiers.fc_net import *\n",
    "from cs231n.data_utils import get_CIFAR10_data\n",
    "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n",
    "from cs231n.solver import Solver\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "def rel_error(x, y):\n",
    "  \"\"\" returns relative error \"\"\"\n",
    "  return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": [
     "pdf-ignore"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('X_train: ', (49000, 3, 32, 32))\n",
      "('y_train: ', (49000,))\n",
      "('X_val: ', (1000, 3, 32, 32))\n",
      "('y_val: ', (1000,))\n",
      "('X_test: ', (1000, 3, 32, 32))\n",
      "('y_test: ', (1000,))\n"
     ]
    }
   ],
   "source": [
    "# Load the (preprocessed) CIFAR10 data.\n",
    "\n",
    "data = get_CIFAR10_data()\n",
    "for k, v in list(data.items()):\n",
    "  print(('%s: ' % k, v.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: forward\n",
    "Open the file `cs231n/layers.py` and implement the `affine_forward` function.\n",
    "\n",
    "Once you are done you can test your implementaion by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_forward function:\n",
      "difference:  9.769849468192957e-10\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_forward function\n",
    "\n",
    "num_inputs = 2\n",
    "input_shape = (4, 5, 6)\n",
    "output_dim = 3\n",
    "\n",
    "input_size = num_inputs * np.prod(input_shape)\n",
    "weight_size = output_dim * np.prod(input_shape)\n",
    "\n",
    "x = np.linspace(-0.1, 0.5, num=input_size).reshape(num_inputs, *input_shape)\n",
    "w = np.linspace(-0.2, 0.3, num=weight_size).reshape(np.prod(input_shape), output_dim)\n",
    "b = np.linspace(-0.3, 0.1, num=output_dim)\n",
    "\n",
    "out, _ = affine_forward(x, w, b)\n",
    "correct_out = np.array([[ 1.49834967,  1.70660132,  1.91485297],\n",
    "                        [ 3.25553199,  3.5141327,   3.77273342]])\n",
    "\n",
    "# Compare your output with ours. The error should be around e-9 or less.\n",
    "print('Testing affine_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Affine layer: backward\n",
    "Now implement the `affine_backward` function and test your implementation using numeric gradient checking."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_backward function:\n",
      "dx error:  5.399100368651805e-11\n",
      "dw error:  9.904211865398145e-11\n",
      "db error:  2.4122867568119087e-11\n"
     ]
    }
   ],
   "source": [
    "# Test the affine_backward function\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 2, 3)\n",
    "w = np.random.randn(6, 5)\n",
    "b = np.random.randn(5)\n",
    "dout = np.random.randn(10, 5)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "_, cache = affine_forward(x, w, b)\n",
    "dx, dw, db = affine_backward(dout, cache)\n",
    "\n",
    "# The error should be around e-10 or less\n",
    "print('Testing affine_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: forward\n",
    "Implement the forward pass for the ReLU activation function in the `relu_forward` function and test your implementation using the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_forward function:\n",
      "difference:  4.999999798022158e-08\n"
     ]
    }
   ],
   "source": [
    "# Test the relu_forward function\n",
    "\n",
    "x = np.linspace(-0.5, 0.5, num=12).reshape(3, 4)\n",
    "\n",
    "out, _ = relu_forward(x)\n",
    "correct_out = np.array([[ 0.,          0.,          0.,          0.,        ],\n",
    "                        [ 0.,          0.,          0.04545455,  0.13636364,],\n",
    "                        [ 0.22727273,  0.31818182,  0.40909091,  0.5,       ]])\n",
    "\n",
    "# Compare your output with ours. The error should be on the order of e-8\n",
    "print('Testing relu_forward function:')\n",
    "print('difference: ', rel_error(out, correct_out))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ReLU activation: backward\n",
    "Now implement the backward pass for the ReLU activation function in the `relu_backward` function and test your implementation using numeric gradient checking:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing relu_backward function:\n",
      "dx error:  3.2756349136310288e-12\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "x = np.random.randn(10, 10)\n",
    "dout = np.random.randn(*x.shape)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: relu_forward(x)[0], x, dout)\n",
    "\n",
    "_, cache = relu_forward(x)\n",
    "dx = relu_backward(dout, cache)\n",
    "\n",
    "# The error should be on the order of e-12\n",
    "print('Testing relu_backward function:')\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 1: \n",
    "\n",
    "We've only asked you to implement ReLU, but there are a number of different activation functions that one could use in neural networks, each with its pros and cons. In particular, an issue commonly seen with activation functions is getting zero (or close to zero) gradient flow during backpropagation. Which of the following activation functions have this problem? If you consider these functions in the one dimensional case, what types of input would lead to this behaviour?\n",
    "1. Sigmoid\n",
    "2. ReLU\n",
    "3. Leaky ReLU\n",
    "\n",
    "## Answer:\n",
    "[FILL THIS IN]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# \"Sandwich\" layers\n",
    "There are some common patterns of layers that are frequently used in neural nets. For example, affine layers are frequently followed by a ReLU nonlinearity. To make these common patterns easy, we define several convenience layers in the file `cs231n/layer_utils.py`.\n",
    "\n",
    "For now take a look at the `affine_relu_forward` and `affine_relu_backward` functions, and run the following to numerically gradient check the backward pass:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing affine_relu_forward and affine_relu_backward:\n",
      "dx error:  2.299579177309368e-11\n",
      "dw error:  8.162011105764925e-11\n",
      "db error:  7.826724021458994e-12\n"
     ]
    }
   ],
   "source": [
    "from cs231n.layer_utils import affine_relu_forward, affine_relu_backward\n",
    "np.random.seed(231)\n",
    "x = np.random.randn(2, 3, 4)\n",
    "w = np.random.randn(12, 10)\n",
    "b = np.random.randn(10)\n",
    "dout = np.random.randn(2, 10)\n",
    "\n",
    "out, cache = affine_relu_forward(x, w, b)\n",
    "dx, dw, db = affine_relu_backward(dout, cache)\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(lambda x: affine_relu_forward(x, w, b)[0], x, dout)\n",
    "dw_num = eval_numerical_gradient_array(lambda w: affine_relu_forward(x, w, b)[0], w, dout)\n",
    "db_num = eval_numerical_gradient_array(lambda b: affine_relu_forward(x, w, b)[0], b, dout)\n",
    "\n",
    "# Relative error should be around e-10 or less\n",
    "print('Testing affine_relu_forward and affine_relu_backward:')\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dw error: ', rel_error(dw_num, dw))\n",
    "print('db error: ', rel_error(db_num, db))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loss layers: Softmax and SVM\n",
    "You implemented these loss functions in the last assignment, so we'll give them to you for free here. You should still make sure you understand how they work by looking at the implementations in `cs231n/layers.py`.\n",
    "\n",
    "You can make sure that the implementations are correct by running the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing svm_loss:\n",
      "loss:  8.999602749096233\n",
      "dx error:  1.4021566006651672e-09\n",
      "\n",
      "Testing softmax_loss:\n",
      "loss:  2.302545844500738\n",
      "dx error:  9.384673161989355e-09\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "num_classes, num_inputs = 10, 50\n",
    "x = 0.001 * np.random.randn(num_inputs, num_classes)\n",
    "y = np.random.randint(num_classes, size=num_inputs)\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: svm_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = svm_loss(x, y)\n",
    "\n",
    "# Test svm_loss function. Loss should be around 9 and dx error should be around the order of e-9\n",
    "print('Testing svm_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "\n",
    "dx_num = eval_numerical_gradient(lambda x: softmax_loss(x, y)[0], x, verbose=False)\n",
    "loss, dx = softmax_loss(x, y)\n",
    "\n",
    "# Test softmax_loss function. Loss should be close to 2.3 and dx error should be around e-8\n",
    "print('\\nTesting softmax_loss:')\n",
    "print('loss: ', loss)\n",
    "print('dx error: ', rel_error(dx_num, dx))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Two-layer network\n",
    "In the previous assignment you implemented a two-layer neural network in a single monolithic class. Now that you have implemented modular versions of the necessary layers, you will reimplement the two layer network using these modular implementations.\n",
    "\n",
    "Open the file `cs231n/classifiers/fc_net.py` and complete the implementation of the `TwoLayerNet` class. This class will serve as a model for the other networks you will implement in this assignment, so read through it to make sure you understand the API. You can run the cell below to test your implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Testing initialization ... \n",
      "Testing test-time forward pass ... \n",
      "Testing training loss (no regularization)\n",
      "Running numeric gradient check with reg =  0.0\n",
      "W1 relative error: 1.83e-08\n",
      "W2 relative error: 3.31e-10\n",
      "b1 relative error: 9.83e-09\n",
      "b2 relative error: 4.33e-10\n",
      "Running numeric gradient check with reg =  0.7\n",
      "W1 relative error: 2.53e-07\n",
      "W2 relative error: 7.98e-08\n",
      "b1 relative error: 1.35e-08\n",
      "b2 relative error: 9.09e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H, C = 3, 5, 50, 7\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=N)\n",
    "\n",
    "std = 1e-3\n",
    "model = TwoLayerNet(input_dim=D, hidden_dim=H, num_classes=C, weight_scale=std)\n",
    "\n",
    "print('Testing initialization ... ')\n",
    "W1_std = abs(model.params['W1'].std() - std)\n",
    "b1 = model.params['b1']\n",
    "W2_std = abs(model.params['W2'].std() - std)\n",
    "b2 = model.params['b2']\n",
    "assert W1_std < std / 10, 'First layer weights do not seem right'\n",
    "assert np.all(b1 == 0), 'First layer biases do not seem right'\n",
    "assert W2_std < std / 10, 'Second layer weights do not seem right'\n",
    "assert np.all(b2 == 0), 'Second layer biases do not seem right'\n",
    "\n",
    "print('Testing test-time forward pass ... ')\n",
    "model.params['W1'] = np.linspace(-0.7, 0.3, num=D*H).reshape(D, H)\n",
    "model.params['b1'] = np.linspace(-0.1, 0.9, num=H)\n",
    "model.params['W2'] = np.linspace(-0.3, 0.4, num=H*C).reshape(H, C)\n",
    "model.params['b2'] = np.linspace(-0.9, 0.1, num=C)\n",
    "X = np.linspace(-5.5, 4.5, num=N*D).reshape(D, N).T\n",
    "scores = model.loss(X)\n",
    "correct_scores = np.asarray(\n",
    "  [[11.53165108,  12.2917344,   13.05181771,  13.81190102,  14.57198434, 15.33206765,  16.09215096],\n",
    "   [12.05769098,  12.74614105,  13.43459113,  14.1230412,   14.81149128, 15.49994135,  16.18839143],\n",
    "   [12.58373087,  13.20054771,  13.81736455,  14.43418138,  15.05099822, 15.66781506,  16.2846319 ]])\n",
    "scores_diff = np.abs(scores - correct_scores).sum()\n",
    "assert scores_diff < 1e-6, 'Problem with test-time forward pass'\n",
    "\n",
    "print('Testing training loss (no regularization)')\n",
    "y = np.asarray([0, 5, 1])\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 3.4702243556\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with training-time loss'\n",
    "\n",
    "model.reg = 1.0\n",
    "loss, grads = model.loss(X, y)\n",
    "correct_loss = 26.5948426952\n",
    "assert abs(loss - correct_loss) < 1e-10, 'Problem with regularization loss'\n",
    "\n",
    "# Errors should be around e-7 or less\n",
    "for reg in [0.0, 0.7]:\n",
    "  print('Running numeric gradient check with reg = ', reg)\n",
    "  model.reg = reg\n",
    "  loss, grads = model.loss(X, y)\n",
    "\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solver\n",
    "In the previous assignment, the logic for training models was coupled to the models themselves. Following a more modular design, for this assignment we have split the logic for training models into a separate class.\n",
    "\n",
    "Open the file `cs231n/solver.py` and read through it to familiarize yourself with the API. After doing so, use a `Solver` instance to train a `TwoLayerNet` that achieves at least `50%` accuracy on the validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "tln_solver_accuracy"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(49000, 3, 32, 32)\n",
      "(Iteration 1 / 4900) loss: 2.304060\n",
      "(Epoch 0 / 10) train acc: 0.092000; val_acc: 0.073000\n",
      "(Iteration 101 / 4900) loss: 1.898232\n",
      "(Iteration 201 / 4900) loss: 1.935383\n",
      "(Iteration 301 / 4900) loss: 1.810089\n",
      "(Iteration 401 / 4900) loss: 1.546397\n",
      "(Epoch 1 / 10) train acc: 0.407000; val_acc: 0.414000\n",
      "(Iteration 501 / 4900) loss: 1.533100\n",
      "(Iteration 601 / 4900) loss: 1.672955\n",
      "(Iteration 701 / 4900) loss: 1.700041\n",
      "(Iteration 801 / 4900) loss: 1.660656\n",
      "(Iteration 901 / 4900) loss: 1.510292\n",
      "(Epoch 2 / 10) train acc: 0.482000; val_acc: 0.475000\n",
      "(Iteration 1001 / 4900) loss: 1.442900\n",
      "(Iteration 1101 / 4900) loss: 1.401469\n",
      "(Iteration 1201 / 4900) loss: 1.682366\n",
      "(Iteration 1301 / 4900) loss: 1.512640\n",
      "(Iteration 1401 / 4900) loss: 1.266091\n",
      "(Epoch 3 / 10) train acc: 0.498000; val_acc: 0.472000\n",
      "(Iteration 1501 / 4900) loss: 1.420029\n",
      "(Iteration 1601 / 4900) loss: 1.381456\n",
      "(Iteration 1701 / 4900) loss: 1.275870\n",
      "(Iteration 1801 / 4900) loss: 1.429819\n",
      "(Iteration 1901 / 4900) loss: 1.405315\n",
      "(Epoch 4 / 10) train acc: 0.522000; val_acc: 0.501000\n",
      "(Iteration 2001 / 4900) loss: 1.391779\n",
      "(Iteration 2101 / 4900) loss: 1.382239\n",
      "(Iteration 2201 / 4900) loss: 1.304908\n",
      "(Iteration 2301 / 4900) loss: 1.346288\n",
      "(Iteration 2401 / 4900) loss: 1.346335\n",
      "(Epoch 5 / 10) train acc: 0.522000; val_acc: 0.516000\n",
      "(Iteration 2501 / 4900) loss: 1.470171\n",
      "(Iteration 2601 / 4900) loss: 1.335708\n",
      "(Iteration 2701 / 4900) loss: 1.145729\n",
      "(Iteration 2801 / 4900) loss: 1.292980\n",
      "(Iteration 2901 / 4900) loss: 1.299634\n",
      "(Epoch 6 / 10) train acc: 0.528000; val_acc: 0.510000\n",
      "(Iteration 3001 / 4900) loss: 1.279773\n",
      "(Iteration 3101 / 4900) loss: 1.373902\n",
      "(Iteration 3201 / 4900) loss: 1.340805\n",
      "(Iteration 3301 / 4900) loss: 1.320507\n",
      "(Iteration 3401 / 4900) loss: 1.431221\n",
      "(Epoch 7 / 10) train acc: 0.557000; val_acc: 0.502000\n",
      "(Iteration 3501 / 4900) loss: 1.280879\n",
      "(Iteration 3601 / 4900) loss: 1.210355\n",
      "(Iteration 3701 / 4900) loss: 1.269537\n",
      "(Iteration 3801 / 4900) loss: 1.193084\n",
      "(Iteration 3901 / 4900) loss: 1.209574\n",
      "(Epoch 8 / 10) train acc: 0.563000; val_acc: 0.504000\n",
      "(Iteration 4001 / 4900) loss: 1.276766\n",
      "(Iteration 4101 / 4900) loss: 1.375010\n",
      "(Iteration 4201 / 4900) loss: 1.220772\n",
      "(Iteration 4301 / 4900) loss: 1.104540\n",
      "(Iteration 4401 / 4900) loss: 1.338059\n",
      "(Epoch 9 / 10) train acc: 0.593000; val_acc: 0.508000\n",
      "(Iteration 4501 / 4900) loss: 1.054759\n",
      "(Iteration 4601 / 4900) loss: 1.329335\n",
      "(Iteration 4701 / 4900) loss: 1.111914\n",
      "(Iteration 4801 / 4900) loss: 1.082243\n",
      "(Epoch 10 / 10) train acc: 0.595000; val_acc: 0.510000\n"
     ]
    }
   ],
   "source": [
    "model = TwoLayerNet()\n",
    "solver = None\n",
    "\n",
    "##############################################################################\n",
    "# TODO: Use a Solver instance to train a TwoLayerNet that achieves at least  #\n",
    "# 50% accuracy on the validation set.                                        #\n",
    "##############################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "pass\n",
    "data = {\n",
    "      'X_train': data['X_train'],\n",
    "      'y_train': data['y_train'],\n",
    "      'X_val': data['X_val'],\n",
    "      'y_val': data['y_val'],\n",
    "    }\n",
    "print(data['X_train'].shape)\n",
    "solver = Solver(model, data,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                    'learning_rate': 0.5e-3,\n",
    "                },\n",
    "                lr_decay=0.95,\n",
    "                num_epochs=10, batch_size=100,\n",
    "                print_every=100)\n",
    "solver.train()\n",
    "\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "##############################################################################\n",
    "#                             END OF YOUR CODE                               #\n",
    "##############################################################################"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x864 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Run this cell to visualize training loss and train / val accuracy\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.title('Accuracy')\n",
    "plt.plot(solver.train_acc_history, '-o', label='train')\n",
    "plt.plot(solver.val_acc_history, '-o', label='val')\n",
    "plt.plot([0.5] * len(solver.val_acc_history), 'k--')\n",
    "plt.xlabel('Epoch')\n",
    "plt.legend(loc='lower right')\n",
    "plt.gcf().set_size_inches(15, 12)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multilayer network\n",
    "Next you will implement a fully-connected network with an arbitrary number of hidden layers.\n",
    "\n",
    "Read through the `FullyConnectedNet` class in the file `cs231n/classifiers/fc_net.py`.\n",
    "\n",
    "Implement the initialization, the forward pass, and the backward pass. For the moment don't worry about implementing dropout or batch/layer normalization; we will add those features soon."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initial loss and gradient check\n",
    "\n",
    "As a sanity check, run the following to check the initial loss and to gradient check the network both with and without regularization. Do the initial losses seem reasonable?\n",
    "\n",
    "For gradient checking, you should expect to see errors around 1e-7 or less."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As another sanity check, make sure you can overfit a small dataset of 50 images. First we will try a three-layer network with 100 units in each hidden layer. In the following cell, tweak the **learning rate** and **weight initialization scale** to overfit and achieve 100% training accuracy within 20 epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running check with reg =  0\n",
      "Initial loss:  2.3004790897684924\n",
      "W1 relative error: 1.48e-07\n",
      "W2 relative error: 2.21e-05\n",
      "W3 relative error: 3.53e-07\n",
      "b1 relative error: 5.38e-09\n",
      "b2 relative error: 2.09e-09\n",
      "b3 relative error: 5.80e-11\n",
      "Running check with reg =  3.14\n",
      "Initial loss:  7.052114776533016\n",
      "W1 relative error: 1.14e-08\n",
      "W2 relative error: 6.87e-08\n",
      "W3 relative error: 3.48e-08\n",
      "b1 relative error: 1.48e-08\n",
      "b2 relative error: 1.72e-09\n",
      "b3 relative error: 1.80e-10\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H1, H2, C = 2, 15, 20, 30, 10\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=(N,))\n",
    "\n",
    "for reg in [0, 3.14]:\n",
    "  print('Running check with reg = ', reg)\n",
    "  model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n",
    "                            reg=reg, weight_scale=5e-2, dtype=np.float64)\n",
    "\n",
    "  loss, grads = model.loss(X, y)\n",
    "  print('Initial loss: ', loss)\n",
    "  \n",
    "  # Most of the errors should be on the order of e-7 or smaller.   \n",
    "  # NOTE: It is fine however to see an error for W2 on the order of e-5\n",
    "  # for the check when reg = 0.0\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 2.718209\n",
      "(Epoch 0 / 20) train acc: 0.180000; val_acc: 0.126000\n",
      "(Epoch 1 / 20) train acc: 0.320000; val_acc: 0.141000\n",
      "(Epoch 2 / 20) train acc: 0.420000; val_acc: 0.149000\n",
      "(Epoch 3 / 20) train acc: 0.520000; val_acc: 0.161000\n",
      "(Epoch 4 / 20) train acc: 0.640000; val_acc: 0.164000\n",
      "(Epoch 5 / 20) train acc: 0.680000; val_acc: 0.166000\n",
      "(Iteration 11 / 40) loss: 0.781240\n",
      "(Epoch 6 / 20) train acc: 0.680000; val_acc: 0.163000\n",
      "(Epoch 7 / 20) train acc: 0.780000; val_acc: 0.183000\n",
      "(Epoch 8 / 20) train acc: 0.820000; val_acc: 0.177000\n",
      "(Epoch 9 / 20) train acc: 0.860000; val_acc: 0.183000\n",
      "(Epoch 10 / 20) train acc: 0.860000; val_acc: 0.164000\n",
      "(Iteration 21 / 40) loss: 0.531304\n",
      "(Epoch 11 / 20) train acc: 0.880000; val_acc: 0.172000\n",
      "(Epoch 12 / 20) train acc: 0.920000; val_acc: 0.167000\n",
      "(Epoch 13 / 20) train acc: 0.920000; val_acc: 0.165000\n",
      "(Epoch 14 / 20) train acc: 0.940000; val_acc: 0.174000\n",
      "(Epoch 15 / 20) train acc: 0.940000; val_acc: 0.173000\n",
      "(Iteration 31 / 40) loss: 0.479873\n",
      "(Epoch 16 / 20) train acc: 0.960000; val_acc: 0.170000\n",
      "(Epoch 17 / 20) train acc: 0.980000; val_acc: 0.162000\n",
      "(Epoch 18 / 20) train acc: 0.980000; val_acc: 0.179000\n",
      "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.176000\n",
      "(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.177000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a three-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "\n",
    "num_train = 50\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "weight_scale = 2e-2   # Experiment with this!\n",
    "learning_rate = 1e-3  # Experiment with this!\n",
    "model = FullyConnectedNet([100, 100],\n",
    "              weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now try to use a five-layer network with 100 units on each layer to overfit 50 training examples. Again, you will have to adjust the learning rate and weight initialization scale, but you should be able to achieve 100% training accuracy within 20 epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 40) loss: 7.589589\n",
      "(Epoch 0 / 20) train acc: 0.200000; val_acc: 0.121000\n",
      "(Epoch 1 / 20) train acc: 0.260000; val_acc: 0.100000\n",
      "(Epoch 2 / 20) train acc: 0.460000; val_acc: 0.109000\n",
      "(Epoch 3 / 20) train acc: 0.760000; val_acc: 0.118000\n",
      "(Epoch 4 / 20) train acc: 0.860000; val_acc: 0.126000\n",
      "(Epoch 5 / 20) train acc: 0.940000; val_acc: 0.134000\n",
      "(Iteration 11 / 40) loss: 0.543069\n",
      "(Epoch 6 / 20) train acc: 0.980000; val_acc: 0.123000\n",
      "(Epoch 7 / 20) train acc: 1.000000; val_acc: 0.123000\n",
      "(Epoch 8 / 20) train acc: 1.000000; val_acc: 0.127000\n",
      "(Epoch 9 / 20) train acc: 1.000000; val_acc: 0.127000\n",
      "(Epoch 10 / 20) train acc: 1.000000; val_acc: 0.131000\n",
      "(Iteration 21 / 40) loss: 0.153287\n",
      "(Epoch 11 / 20) train acc: 1.000000; val_acc: 0.132000\n",
      "(Epoch 12 / 20) train acc: 1.000000; val_acc: 0.130000\n",
      "(Epoch 13 / 20) train acc: 1.000000; val_acc: 0.132000\n",
      "(Epoch 14 / 20) train acc: 1.000000; val_acc: 0.137000\n",
      "(Epoch 15 / 20) train acc: 1.000000; val_acc: 0.132000\n",
      "(Iteration 31 / 40) loss: 0.066563\n",
      "(Epoch 16 / 20) train acc: 1.000000; val_acc: 0.128000\n",
      "(Epoch 17 / 20) train acc: 1.000000; val_acc: 0.132000\n",
      "(Epoch 18 / 20) train acc: 1.000000; val_acc: 0.132000\n",
      "(Epoch 19 / 20) train acc: 1.000000; val_acc: 0.132000\n",
      "(Epoch 20 / 20) train acc: 1.000000; val_acc: 0.133000\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# TODO: Use a five-layer Net to overfit 50 training examples by \n",
    "# tweaking just the learning rate and initialization scale.\n",
    "\n",
    "num_train = 50\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "learning_rate = 2e-3  # Experiment with this!\n",
    "weight_scale = 6e-2   # Experiment with this!\n",
    "model = FullyConnectedNet([100, 100, 100, 100],\n",
    "                weight_scale=weight_scale, dtype=np.float64)\n",
    "solver = Solver(model, small_data,\n",
    "                print_every=10, num_epochs=20, batch_size=25,\n",
    "                update_rule='sgd',\n",
    "                optim_config={\n",
    "                  'learning_rate': learning_rate,\n",
    "                }\n",
    "         )\n",
    "solver.train()\n",
    "\n",
    "plt.plot(solver.loss_history, 'o')\n",
    "plt.title('Training loss history')\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Training loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 2: \n",
    "Did you notice anything about the comparative difficulty of training the three-layer net vs training the five layer net? In particular, based on your experience, which network seemed more sensitive to the initialization scale? Why do you think that is the case?\n",
    "\n",
    "## Answer:\n",
    "[FILL THIS IN]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Update rules\n",
    "So far we have used vanilla stochastic gradient descent (SGD) as our update rule. More sophisticated update rules can make it easier to train deep networks. We will implement a few of the most commonly used update rules and compare them to vanilla SGD."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SGD+Momentum\n",
    "Stochastic gradient descent with momentum is a widely used update rule that tends to make deep networks converge faster than vanilla stochastic gradient descent. See the Momentum Update section at http://cs231n.github.io/neural-networks-3/#sgd for more information.\n",
    "\n",
    "Open the file `cs231n/optim.py` and read the documentation at the top of the file to make sure you understand the API. Implement the SGD+momentum update rule in the function `sgd_momentum` and run the following to check your implementation. You should see errors less than e-8."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  8.882347033505819e-09\n",
      "velocity error:  4.269287743278663e-09\n"
     ]
    }
   ],
   "source": [
    "from cs231n.optim import sgd_momentum\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-3, 'velocity': v}\n",
    "next_w, _ = sgd_momentum(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [ 0.1406,      0.20738947,  0.27417895,  0.34096842,  0.40775789],\n",
    "  [ 0.47454737,  0.54133684,  0.60812632,  0.67491579,  0.74170526],\n",
    "  [ 0.80849474,  0.87528421,  0.94207368,  1.00886316,  1.07565263],\n",
    "  [ 1.14244211,  1.20923158,  1.27602105,  1.34281053,  1.4096    ]])\n",
    "expected_velocity = np.asarray([\n",
    "  [ 0.5406,      0.55475789,  0.56891579, 0.58307368,  0.59723158],\n",
    "  [ 0.61138947,  0.62554737,  0.63970526,  0.65386316,  0.66802105],\n",
    "  [ 0.68217895,  0.69633684,  0.71049474,  0.72465263,  0.73881053],\n",
    "  [ 0.75296842,  0.76712632,  0.78128421,  0.79544211,  0.8096    ]])\n",
    "\n",
    "# Should see relative errors around e-8 or less\n",
    "print('next_w error: ', rel_error(next_w, expected_next_w))\n",
    "print('velocity error: ', rel_error(expected_velocity, config['velocity']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have done so, run the following to train a six-layer network with both SGD and SGD+momentum. You should see the SGD+momentum update rule converge faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  sgd\n",
      "(Iteration 1 / 200) loss: 2.538342\n",
      "(Epoch 0 / 5) train acc: 0.105000; val_acc: 0.092000\n",
      "(Iteration 11 / 200) loss: 2.342943\n",
      "(Iteration 21 / 200) loss: 2.265832\n",
      "(Iteration 31 / 200) loss: 2.171540\n",
      "(Epoch 1 / 5) train acc: 0.226000; val_acc: 0.195000\n",
      "(Iteration 41 / 200) loss: 2.128764\n",
      "(Iteration 51 / 200) loss: 2.065261\n",
      "(Iteration 61 / 200) loss: 2.096427\n",
      "(Iteration 71 / 200) loss: 2.151511\n",
      "(Epoch 2 / 5) train acc: 0.289000; val_acc: 0.224000\n",
      "(Iteration 81 / 200) loss: 1.879474\n",
      "(Iteration 91 / 200) loss: 2.117178\n",
      "(Iteration 101 / 200) loss: 1.954273\n",
      "(Iteration 111 / 200) loss: 1.897304\n",
      "(Epoch 3 / 5) train acc: 0.325000; val_acc: 0.253000\n",
      "(Iteration 121 / 200) loss: 2.024819\n",
      "(Iteration 131 / 200) loss: 1.901890\n",
      "(Iteration 141 / 200) loss: 1.861955\n",
      "(Iteration 151 / 200) loss: 1.860205\n",
      "(Epoch 4 / 5) train acc: 0.346000; val_acc: 0.272000\n",
      "(Iteration 161 / 200) loss: 1.875155\n",
      "(Iteration 171 / 200) loss: 1.838714\n",
      "(Iteration 181 / 200) loss: 1.734114\n",
      "(Iteration 191 / 200) loss: 1.825152\n",
      "(Epoch 5 / 5) train acc: 0.363000; val_acc: 0.298000\n",
      "\n",
      "running with  sgd_momentum\n",
      "(Iteration 1 / 200) loss: 2.645415\n",
      "(Epoch 0 / 5) train acc: 0.120000; val_acc: 0.093000\n",
      "(Iteration 11 / 200) loss: 2.208266\n",
      "(Iteration 21 / 200) loss: 2.020434\n",
      "(Iteration 31 / 200) loss: 2.056276\n",
      "(Epoch 1 / 5) train acc: 0.307000; val_acc: 0.283000\n",
      "(Iteration 41 / 200) loss: 1.874874\n",
      "(Iteration 51 / 200) loss: 1.866570\n",
      "(Iteration 61 / 200) loss: 1.775608\n",
      "(Iteration 71 / 200) loss: 1.785177\n",
      "(Epoch 2 / 5) train acc: 0.387000; val_acc: 0.308000\n",
      "(Iteration 81 / 200) loss: 1.709946\n",
      "(Iteration 91 / 200) loss: 1.737460\n",
      "(Iteration 101 / 200) loss: 1.723136\n",
      "(Iteration 111 / 200) loss: 1.472881\n",
      "(Epoch 3 / 5) train acc: 0.417000; val_acc: 0.328000\n",
      "(Iteration 121 / 200) loss: 1.690080\n",
      "(Iteration 131 / 200) loss: 1.419340\n",
      "(Iteration 141 / 200) loss: 1.629793\n",
      "(Iteration 151 / 200) loss: 1.686398\n",
      "(Epoch 4 / 5) train acc: 0.500000; val_acc: 0.343000\n",
      "(Iteration 161 / 200) loss: 1.339969\n",
      "(Iteration 171 / 200) loss: 1.764631\n",
      "(Iteration 181 / 200) loss: 1.315858\n",
      "(Iteration 191 / 200) loss: 1.484259\n",
      "(Epoch 5 / 5) train acc: 0.538000; val_acc: 0.336000\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\admin\\AppData\\Roaming\\Python\\Python37\\site-packages\\matplotlib\\figure.py:98: MatplotlibDeprecationWarning: \n",
      "Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "  \"Adding an axes using the same arguments as a previous axes \"\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "num_train = 4000\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "solvers = {}\n",
    "\n",
    "for update_rule in ['sgd', 'sgd_momentum']:\n",
    "  print('running with ', update_rule)\n",
    "  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=5, batch_size=100,\n",
    "                  update_rule=update_rule,\n",
    "                  optim_config={\n",
    "                    'learning_rate': 5e-3,\n",
    "                  },\n",
    "                  verbose=True)\n",
    "  solvers[update_rule] = solver\n",
    "  solver.train()\n",
    "  print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in solvers.items():\n",
    "  plt.subplot(3, 1, 1)\n",
    "  plt.plot(solver.loss_history, 'o', label=\"loss_%s\" % update_rule)\n",
    "  \n",
    "  plt.subplot(3, 1, 2)\n",
    "  plt.plot(solver.train_acc_history, '-o', label=\"train_acc_%s\" % update_rule)\n",
    "\n",
    "  plt.subplot(3, 1, 3)\n",
    "  plt.plot(solver.val_acc_history, '-o', label=\"val_acc_%s\" % update_rule)\n",
    "  \n",
    "for i in [1, 2, 3]:\n",
    "  plt.subplot(3, 1, i)\n",
    "  plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RMSProp and Adam\n",
    "RMSProp [1] and Adam [2] are update rules that set per-parameter learning rates by using a running average of the second moments of gradients.\n",
    "\n",
    "In the file `cs231n/optim.py`, implement the RMSProp update rule in the `rmsprop` function and implement the Adam update rule in the `adam` function, and check your implementations using the tests below.\n",
    "\n",
    "**NOTE:** Please implement the _complete_ Adam update rule (with the bias correction mechanism), not the first simplified version mentioned in the course notes. \n",
    "\n",
    "[1] Tijmen Tieleman and Geoffrey Hinton. \"Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude.\" COURSERA: Neural Networks for Machine Learning 4 (2012).\n",
    "\n",
    "[2] Diederik Kingma and Jimmy Ba, \"Adam: A Method for Stochastic Optimization\", ICLR 2015."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  9.524687511038133e-08\n",
      "cache error:  2.6477955807156126e-09\n"
     ]
    }
   ],
   "source": [
    "# Test RMSProp implementation\n",
    "from cs231n.optim import rmsprop\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "cache = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'cache': cache}\n",
    "next_w, _ = rmsprop(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.39223849, -0.34037513, -0.28849239, -0.23659121, -0.18467247],\n",
    "  [-0.132737,   -0.08078555, -0.02881884,  0.02316247,  0.07515774],\n",
    "  [ 0.12716641,  0.17918792,  0.23122175,  0.28326742,  0.33532447],\n",
    "  [ 0.38739248,  0.43947102,  0.49155973,  0.54365823,  0.59576619]])\n",
    "expected_cache = np.asarray([\n",
    "  [ 0.5976,      0.6126277,   0.6277108,   0.64284931,  0.65804321],\n",
    "  [ 0.67329252,  0.68859723,  0.70395734,  0.71937285,  0.73484377],\n",
    "  [ 0.75037008,  0.7659518,   0.78158892,  0.79728144,  0.81302936],\n",
    "  [ 0.82883269,  0.84469141,  0.86060554,  0.87657507,  0.8926    ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('cache error: ', rel_error(expected_cache, config['cache']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "next_w error:  1.0\n",
      "v error:  4.208314038113071e-09\n",
      "m error:  4.214963193114416e-09\n"
     ]
    }
   ],
   "source": [
    "# Test Adam implementation\n",
    "from cs231n.optim import adam\n",
    "\n",
    "N, D = 4, 5\n",
    "w = np.linspace(-0.4, 0.6, num=N*D).reshape(N, D)\n",
    "dw = np.linspace(-0.6, 0.4, num=N*D).reshape(N, D)\n",
    "m = np.linspace(0.6, 0.9, num=N*D).reshape(N, D)\n",
    "v = np.linspace(0.7, 0.5, num=N*D).reshape(N, D)\n",
    "\n",
    "config = {'learning_rate': 1e-2, 'm': m, 'v': v, 't': 5}\n",
    "next_w, _ = adam(w, dw, config=config)\n",
    "\n",
    "expected_next_w = np.asarray([\n",
    "  [-0.40094747, -0.34836187, -0.29577703, -0.24319299, -0.19060977],\n",
    "  [-0.1380274,  -0.08544591, -0.03286534,  0.01971428,  0.0722929],\n",
    "  [ 0.1248705,   0.17744702,  0.23002243,  0.28259667,  0.33516969],\n",
    "  [ 0.38774145,  0.44031188,  0.49288093,  0.54544852,  0.59801459]])\n",
    "expected_v = np.asarray([\n",
    "  [ 0.69966,     0.68908382,  0.67851319,  0.66794809,  0.65738853,],\n",
    "  [ 0.64683452,  0.63628604,  0.6257431,   0.61520571,  0.60467385,],\n",
    "  [ 0.59414753,  0.58362676,  0.57311152,  0.56260183,  0.55209767,],\n",
    "  [ 0.54159906,  0.53110598,  0.52061845,  0.51013645,  0.49966,   ]])\n",
    "expected_m = np.asarray([\n",
    "  [ 0.48,        0.49947368,  0.51894737,  0.53842105,  0.55789474],\n",
    "  [ 0.57736842,  0.59684211,  0.61631579,  0.63578947,  0.65526316],\n",
    "  [ 0.67473684,  0.69421053,  0.71368421,  0.73315789,  0.75263158],\n",
    "  [ 0.77210526,  0.79157895,  0.81105263,  0.83052632,  0.85      ]])\n",
    "\n",
    "# You should see relative errors around e-7 or less\n",
    "print('next_w error: ', rel_error(expected_next_w, next_w))\n",
    "print('v error: ', rel_error(expected_v, config['v']))\n",
    "print('m error: ', rel_error(expected_m, config['m']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have debugged your RMSProp and Adam implementations, run the following to train a pair of deep networks using these new update rules:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "running with  adam\n",
      "(Iteration 1 / 200) loss: 2.605744\n",
      "(Epoch 0 / 5) train acc: 0.086000; val_acc: 0.087000\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "E:\\internship\\code\\cs231n\\assignment2_jupyter\\assignment2\\cs231n\\optim.py:168: RuntimeWarning: divide by zero encountered in true_divide\n",
      "  mt = config['m'] / (1 - config['beta1'] ** config['t'])\n",
      "E:\\internship\\code\\cs231n\\assignment2_jupyter\\assignment2\\cs231n\\optim.py:170: RuntimeWarning: divide by zero encountered in true_divide\n",
      "  vt = config['v'] / (1 - config['beta2'] ** config['t'])\n",
      "E:\\internship\\code\\cs231n\\assignment2_jupyter\\assignment2\\cs231n\\optim.py:171: RuntimeWarning: invalid value encountered in true_divide\n",
      "  next_w = -config['learning_rate'] * mt / (np.sqrt(vt) + config['eps'])\n",
      "E:\\internship\\code\\cs231n\\assignment2_jupyter\\assignment2\\cs231n\\optim.py:168: RuntimeWarning: invalid value encountered in true_divide\n",
      "  mt = config['m'] / (1 - config['beta1'] ** config['t'])\n",
      "E:\\internship\\code\\cs231n\\assignment2_jupyter\\assignment2\\cs231n\\optim.py:170: RuntimeWarning: invalid value encountered in true_divide\n",
      "  vt = config['v'] / (1 - config['beta2'] ** config['t'])\n",
      "E:\\internship\\code\\cs231n\\assignment2_jupyter\\assignment2\\cs231n\\layers.py:129: RuntimeWarning: invalid value encountered in less_equal\n",
      "  dx[x<=0.0]=0\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 11 / 200) loss: nan\n",
      "(Iteration 21 / 200) loss: nan\n",
      "(Iteration 31 / 200) loss: nan\n",
      "(Epoch 1 / 5) train acc: 0.104000; val_acc: 0.087000\n",
      "(Iteration 41 / 200) loss: nan\n",
      "(Iteration 51 / 200) loss: nan\n",
      "(Iteration 61 / 200) loss: nan\n",
      "(Iteration 71 / 200) loss: nan\n",
      "(Epoch 2 / 5) train acc: 0.116000; val_acc: 0.087000\n",
      "(Iteration 81 / 200) loss: nan\n",
      "(Iteration 91 / 200) loss: nan\n",
      "(Iteration 101 / 200) loss: nan\n",
      "(Iteration 111 / 200) loss: nan\n",
      "(Epoch 3 / 5) train acc: 0.097000; val_acc: 0.087000\n",
      "(Iteration 121 / 200) loss: nan\n",
      "(Iteration 131 / 200) loss: nan\n",
      "(Iteration 141 / 200) loss: nan\n",
      "(Iteration 151 / 200) loss: nan\n",
      "(Epoch 4 / 5) train acc: 0.088000; val_acc: 0.087000\n",
      "(Iteration 161 / 200) loss: nan\n",
      "(Iteration 171 / 200) loss: nan\n",
      "(Iteration 181 / 200) loss: nan\n",
      "(Iteration 191 / 200) loss: nan\n",
      "(Epoch 5 / 5) train acc: 0.120000; val_acc: 0.087000\n",
      "\n",
      "running with  rmsprop\n",
      "(Iteration 1 / 200) loss: 2.500198\n",
      "(Epoch 0 / 5) train acc: 0.164000; val_acc: 0.153000\n",
      "(Iteration 11 / 200) loss: 2.173048\n",
      "(Iteration 21 / 200) loss: 2.003368\n",
      "(Iteration 31 / 200) loss: 1.812818\n",
      "(Epoch 1 / 5) train acc: 0.371000; val_acc: 0.328000\n",
      "(Iteration 41 / 200) loss: 1.638392\n",
      "(Iteration 51 / 200) loss: 1.683404\n",
      "(Iteration 61 / 200) loss: 1.746955\n",
      "(Iteration 71 / 200) loss: 1.789512\n",
      "(Epoch 2 / 5) train acc: 0.420000; val_acc: 0.348000\n",
      "(Iteration 81 / 200) loss: 1.735208\n",
      "(Iteration 91 / 200) loss: 1.747302\n",
      "(Iteration 101 / 200) loss: 1.496302\n",
      "(Iteration 111 / 200) loss: 1.679208\n",
      "(Epoch 3 / 5) train acc: 0.461000; val_acc: 0.367000\n",
      "(Iteration 121 / 200) loss: 1.606263\n",
      "(Iteration 131 / 200) loss: 1.486163\n",
      "(Iteration 141 / 200) loss: 1.516683\n",
      "(Iteration 151 / 200) loss: 1.624048\n",
      "(Epoch 4 / 5) train acc: 0.506000; val_acc: 0.363000\n",
      "(Iteration 161 / 200) loss: 1.552610\n",
      "(Iteration 171 / 200) loss: 1.356205\n",
      "(Iteration 181 / 200) loss: 1.366233\n",
      "(Iteration 191 / 200) loss: 1.407471\n",
      "(Epoch 5 / 5) train acc: 0.537000; val_acc: 0.365000\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learning_rates = {'rmsprop': 1e-4, 'adam': 1e-3}\n",
    "for update_rule in ['adam', 'rmsprop']:\n",
    "  print('running with ', update_rule)\n",
    "  model = FullyConnectedNet([100, 100, 100, 100, 100], weight_scale=5e-2)\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=5, batch_size=100,\n",
    "                  update_rule=update_rule,\n",
    "                  optim_config={\n",
    "                    'learning_rate': learning_rates[update_rule]\n",
    "                  },\n",
    "                  verbose=True)\n",
    "  solvers[update_rule] = solver\n",
    "  solver.train()\n",
    "  print()\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "for update_rule, solver in list(solvers.items()):\n",
    "  plt.subplot(3, 1, 1)\n",
    "  plt.plot(solver.loss_history, 'o', label=update_rule)\n",
    "  \n",
    "  plt.subplot(3, 1, 2)\n",
    "  plt.plot(solver.train_acc_history, '-o', label=update_rule)\n",
    "\n",
    "  plt.subplot(3, 1, 3)\n",
    "  plt.plot(solver.val_acc_history, '-o', label=update_rule)\n",
    "  \n",
    "for i in [1, 2, 3]:\n",
    "  plt.subplot(3, 1, i)\n",
    "  plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "pdf-inline"
    ]
   },
   "source": [
    "## Inline Question 3:\n",
    "\n",
    "AdaGrad, like Adam, is a per-parameter optimization method that uses the following update rule:\n",
    "\n",
    "```\n",
    "cache += dw**2\n",
    "w += - learning_rate * dw / (np.sqrt(cache) + eps)\n",
    "```\n",
    "\n",
    "John notices that when he was training a network with AdaGrad that the updates became very small, and that his network was learning slowly. Using your knowledge of the AdaGrad update rule, why do you think the updates would become very small? Would Adam have the same issue?\n",
    "\n",
    "\n",
    "## Answer: \n",
    "[FILL THIS IN]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Train a good model!\n",
    "Train the best fully-connected model that you can on CIFAR-10, storing your best model in the `best_model` variable. We require you to get at least 50% accuracy on the validation set using a fully-connected net.\n",
    "\n",
    "If you are careful it should be possible to get accuracies above 55%, but we don't require it for this part and won't assign extra credit for doing so. Later in the assignment we will ask you to train the best convolutional network that you can on CIFAR-10, and we would prefer that you spend your effort working on convolutional nets rather than fully-connected nets.\n",
    "\n",
    "You might find it useful to complete the `BatchNormalization.ipynb` and `Dropout.ipynb` notebooks before completing this part, since those techniques can help you train powerful models."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "best_model = None\n",
    "################################################################################\n",
    "# TODO: Train the best FullyConnectedNet that you can on CIFAR-10. You might   #\n",
    "# find batch/layer normalization and dropout useful. Store your best model in  #\n",
    "# the best_model variable.                                                     #\n",
    "################################################################################\n",
    "# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "\n",
    "pass\n",
    "\n",
    "# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n",
    "################################################################################\n",
    "#                              END OF YOUR CODE                                #\n",
    "################################################################################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test your model!\n",
    "Run your best model on the validation and test sets. You should achieve above 50% accuracy on the validation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_test_pred = np.argmax(best_model.loss(data['X_test']), axis=1)\n",
    "y_val_pred = np.argmax(best_model.loss(data['X_val']), axis=1)\n",
    "print('Validation set accuracy: ', (y_val_pred == data['y_val']).mean())\n",
    "print('Test set accuracy: ', (y_test_pred == data['y_test']).mean())"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Edit Metadata",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.10"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "371.333px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
